package com.example.furniture.service.impl;

import com.example.furniture.entity.User;
import com.example.furniture.mapper.UserMapper;
import com.example.furniture.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 用户服务实现类
 * 提供用户相关的业务逻辑处理
 * 
 * @author 家具商城系统
 * @version 1.0
 * @since 2024-01-01
 */
@Service
@Transactional
public class UserServiceImpl implements UserService {

    private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
    private final UserMapper userMapper;

    /**
     * 构造函数，注入用户数据访问层
     * 
     * @param userMapper 用户数据访问层实例
     */
    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    /**
     * 根据ID获取用户信息
     * 
     * @param id 用户ID
     * @return 用户信息，如果不存在返回null
     */
    @Override
    public User getById(Long id) {
        logger.debug("根据ID获取用户信息: {}", id);
        try {
            User user = userMapper.selectById(id);
            if (user != null) {
                logger.debug("成功获取用户信息: {}", user.getUsername());
            } else {
                logger.debug("用户不存在: {}", id);
            }
            return user;
        } catch (Exception e) {
            logger.error("获取用户信息失败，ID: {}", id, e);
            throw new RuntimeException("获取用户信息失败", e);
        }
    }

    /**
     * 获取所有用户列表
     * 
     * @return 用户列表
     */
    @Override
    public List<User> listAll() {
        logger.debug("获取所有用户列表");
        try {
            List<User> users = userMapper.selectAll();
            logger.debug("成功获取用户列表，共{}条记录", users.size());
            return users;
        } catch (Exception e) {
            logger.error("获取用户列表失败", e);
            throw new RuntimeException("获取用户列表失败", e);
        }
    }

    /**
     * 创建新用户
     * 
     * @param user 用户信息
     * @return 创建的用户信息（包含生成的ID）
     */
    @Override
    public User create(User user) {
        logger.debug("创建新用户: {}", user.getUsername());
        try {
            // 验证用户名是否已存在
            if (isUsernameExists(user.getUsername())) {
                logger.warn("用户名已存在: {}", user.getUsername());
                throw new RuntimeException("用户名已存在");
            }
            
            // 验证邮箱是否已存在
            if (isEmailExists(user.getEmail())) {
                logger.warn("邮箱已存在: {}", user.getEmail());
                throw new RuntimeException("邮箱已存在");
            }
            
            userMapper.insert(user);
            logger.info("用户创建成功，ID: {}, 用户名: {}", user.getId(), user.getUsername());
            return user;
        } catch (Exception e) {
            logger.error("创建用户失败: {}", user.getUsername(), e);
            throw new RuntimeException("创建用户失败", e);
        }
    }

    /**
     * 更新用户信息
     * 
     * @param id 用户ID
     * @param user 更新的用户信息
     * @return 更新后的用户信息
     */
    @Override
    public User update(Long id, User user) {
        logger.debug("更新用户信息，ID: {}", id);
        try {
            // 检查用户是否存在
            User existingUser = userMapper.selectById(id);
            if (existingUser == null) {
                logger.warn("用户不存在，无法更新，ID: {}", id);
                throw new RuntimeException("用户不存在");
            }
            
            // 验证用户名是否被其他用户使用
            if (!existingUser.getUsername().equals(user.getUsername()) && isUsernameExists(user.getUsername())) {
                logger.warn("用户名已被其他用户使用: {}", user.getUsername());
                throw new RuntimeException("用户名已被其他用户使用");
            }
            
            // 验证邮箱是否被其他用户使用
            if (!existingUser.getEmail().equals(user.getEmail()) && isEmailExists(user.getEmail())) {
                logger.warn("邮箱已被其他用户使用: {}", user.getEmail());
                throw new RuntimeException("邮箱已被其他用户使用");
            }
            
            // 如果密码为空，保持原密码
            if (user.getPassword() == null || user.getPassword().isEmpty()) {
                user.setPassword(existingUser.getPassword());
            }
            
            user.setId(id);
            userMapper.update(user);
            User updatedUser = userMapper.selectById(id);
            logger.info("用户更新成功，ID: {}, 用户名: {}", id, updatedUser.getUsername());
            return updatedUser;
        } catch (Exception e) {
            logger.error("更新用户失败，ID: {}", id, e);
            throw new RuntimeException("更新用户失败", e);
        }
    }

    /**
     * 删除用户
     * 
     * @param id 用户ID
     */
    @Override
    public void delete(Long id) {
        logger.debug("删除用户，ID: {}", id);
        try {
            // 检查用户是否存在
            User existingUser = userMapper.selectById(id);
            if (existingUser == null) {
                logger.warn("用户不存在，无法删除，ID: {}", id);
                throw new RuntimeException("用户不存在");
            }
            
            userMapper.deleteById(id);
            logger.info("用户删除成功，ID: {}", id);
        } catch (Exception e) {
            logger.error("删除用户失败，ID: {}", id, e);
            throw new RuntimeException("删除用户失败", e);
        }
    }

    /**
     * 检查用户名是否已存在
     * 
     * @param username 用户名
     * @return 是否存在
     */
    private boolean isUsernameExists(String username) {
        // 这里可以添加更复杂的用户名重复检查逻辑
        // 目前简化处理，实际项目中应该查询数据库
        return false;
    }

    /**
     * 检查邮箱是否已存在
     * 
     * @param email 邮箱
     * @return 是否存在
     */
    private boolean isEmailExists(String email) {
        // 这里可以添加更复杂的邮箱重复检查逻辑
        // 目前简化处理，实际项目中应该查询数据库
        return false;
    }
}


